<html>
	<head>
		<meta charset="utf-8"></meta>
		<title>BArray</title>
		<link href="./style.css" rel="stylesheet" type="text/css"/>
	</head>
	<body>
		<div class="class" name="BArray">
			<h1>BArray</h1>
			<p>继承自<a href="BThing.html">BThing</a></p>
			<p id="resume">BArray是数组容器，以连续内存块来管理元素，是高效且常用的容器。<a href="#desc">详细</a></p><h2>public</h2>
			<table id="public">
				<tr><td align="right">inline </td><td><a href="#BArray() :)">BArray</a>() : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BArray(int size) :)">BArray</a>(int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BArray(const T&, int size) :)">BArray</a>(const T&amp; v, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BArray(const UT*, int size) :)">BArray</a>(const UT* values, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BArray(const T*, int size) :)">BArray</a>(const T* values, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BArray(const BArray<UT>& other) :)">BArray</a>(const BArray&lt;UT&gt;&amp; other) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BArray(const BArray& other) :)">BArray</a>(const BArray&amp; other) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BArray(const BArray<UT>&, int, int size) :)">BArray</a>(const BArray&lt;UT&gt;&amp; other, int pos, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#BArray(const BArray&, int, int size) :)">BArray</a>(const BArray&amp; other, int pos, int size) : _def();</td></tr>
				<tr><td align="right">inline </td><td><a href="#~BArray()">~BArray</a>();</td></tr>
				<tr><td align="right">inline int </td><td><a href="#size() const">size</a>() const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#capacity() const">capacity</a>() const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#empty() const">empty</a>() const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#reset()">reset</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#clear()">clear</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#relax()">relax</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#reset(int)">reset</a>(int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#resize(int)">resize</a>(int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#reserve(int)">reserve</a>(int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#check(int) const">check</a>(int index) const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#set(int, const T&)">set</a>(int pos, const T&amp; value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#set(int, const T*, int)">set</a>(int pos, const T* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#set(int, const BArray<T>&)">set</a>(int pos, const BArray&lt;T&gt;&amp; other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#fill(const T&)">fill</a>(const T&amp; value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#fill(const T*, int)">fill</a>(const T* data, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#fill(const BArray<T>&)">fill</a>(const BArray&lt;T&gt;&amp; other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#fill(int, const T&, int)">fill</a>(int pos, const T&amp; value, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#fill(int, const T*, int)">fill</a>(int pos, const T* data, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#fill(int, const BArray<T>&)">fill</a>(int pos, const BArray&lt;T&gt;&amp; other);</td></tr>
				<tr><td align="right">inline int </td><td><a href="#find(const UT&,int) const">find</a>(const UT&amp; value, int pos = 0) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#find(int, const UT*, int) const">find</a>(int pos, const UT* values, int size) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#find(int, const T*, int) const">find</a>(int pos, const T* values, int size) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#find(int, const BArray<UT>&) const">find</a>(int pos, const BArray&lt;UT&gt;&amp; other) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#find(int, const BArray&) const">find</a>(int pos, const BArray&amp; other) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#rfind(const UT&,int) const">rfind</a>(const UT&amp; value, int pos = -1) const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#find_min() const">find_min</a>() const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#find_max() const">find_max</a>() const;</td></tr>
				<tr><td align="right">inline int </td><td><a href="#count(const UT&) const">count</a>(const UT&amp; value) const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#contain(const UT&) const">contain</a>(const UT&amp; value) const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#move(int, int)">move</a>(int index, int dest);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#swap(int, int)">swap</a>(int index0, int index1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#reverse()">reverse</a>();</td></tr>
				<tr><td align="right">inline int </td><td><a href="#replace(const T&, const T&)">replace</a>(const T&amp; oldValue, const T&amp; newValue);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#sort(const FUNC&,int)">sort</a>(const FUNC&amp; func, int dir = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#sort(int)">sort</a>(int dir = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#raise(const UT&)">raise</a>(const UT&amp; value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#lower(const UT&)">lower</a>(const UT&amp; value);</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#first()">first</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#first() const">first</a>() const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#middle()">middle</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#middle() const">middle</a>() const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#last()">last</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#last() const">last</a>() const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#min()">min</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#min() const">min</a>() const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#max()">max</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#max() const">max</a>() const;</td></tr>
				<tr><td align="right">inline T* </td><td><a href="#data()">data</a>();</td></tr>
				<tr><td align="right">inline const T* </td><td><a href="#data() const">data</a>() const;</td></tr>
				<tr><td align="right">inline T* </td><td><a href="#data(int)">data</a>(int index);</td></tr>
				<tr><td align="right">inline const T* </td><td><a href="#data(int) const">data</a>(int index) const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#at(int)">at</a>(int index);</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#at(int) const">at</a>(int index) const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#def()">def</a>();</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#def() const">def</a>() const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#expand(int)">expand</a>(int size);</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#append()">append</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const UT&,int)">append</a>(const UT&amp; value, int size = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const T&,int)">append</a>(const T&amp; value, int size = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const UT*, int)">append</a>(const UT* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const T*, int)">append</a>(const T* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const BArray<UT>&,int,int)">append</a>(const BArray&lt;UT&gt;&amp; other, int pos = 0, int size = -1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#append(const BArray&,int,int)">append</a>(const BArray&amp; other, int pos = 0, int size = -1);</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#prepend()">prepend</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const UT&,int)">prepend</a>(const UT&amp; value, int size = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const T&,int)">prepend</a>(const T&amp; value, int size = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const UT*, int)">prepend</a>(const UT* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const T*, int)">prepend</a>(const T* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const BArray<UT>&,int,int)">prepend</a>(const BArray&lt;UT&gt;&amp; other, int pos = 0, int size = -1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#prepend(const BArray&,int,int)">prepend</a>(const BArray&amp; other, int pos = 0, int size = -1);</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#insert(int)">insert</a>(int pos);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const UT&,int)">insert</a>(int pos, const UT&amp; value, int size = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const T&,int)">insert</a>(int pos, const T&amp; value, int size = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const UT*, int)">insert</a>(int pos, const UT* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const T*, int)">insert</a>(int pos, const T* values, int size);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const BArray<UT>&,int,int)">insert</a>(int pos, const BArray&lt;UT&gt;&amp; other, int first = 0, int size = -1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#insert(int, const BArray&,int,int)">insert</a>(int pos, const BArray&amp; other, int first = 0, int size = -1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(int,int)">remove</a>(int pos, int count = 1);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const UT&)">remove</a>(const UT&amp; value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const T&)">remove</a>(const T&amp; value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const BArray<UT>&)">remove</a>(const BArray&lt;UT&gt;&amp; other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#remove(const BArray&)">remove</a>(const BArray&amp; other);</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#push()">push</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#push(const T&)">push</a>(const T&amp; value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#pop()">pop</a>();</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#pop(T&)">pop</a>(T&amp; value);</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#operator()(int)">operator</a>()(int index);</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#operator()(int) const">operator</a>()(int index) const;</td></tr>
				<tr><td align="right">inline T&amp; </td><td><a href="#operator[](int)">operator[]</a>(int index);</td></tr>
				<tr><td align="right">inline const T&amp; </td><td><a href="#operator[](int) const">operator[]</a>(int index) const;</td></tr>
				<tr><td align="right">inline const BArray&amp; </td><td><a href="#operator = (const BArray<UT>&)">operator = </a>(const BArray&lt;UT&gt;&amp; other);</td></tr>
				<tr><td align="right">inline const BArray&amp; </td><td><a href="#operator = (const BArray&)">operator = </a>(const BArray&amp; other);</td></tr>
				<tr><td align="right">inline BArray </td><td><a href="#operator + (const UT&) const">operator + </a>(const UT&amp; value) const;</td></tr>
				<tr><td align="right">inline BArray </td><td><a href="#operator + (const BArray&) const">operator + </a>(const BArray&amp; other) const;</td></tr>
				<tr><td align="right">inline void </td><td><a href="#operator += (const UT&)">operator += </a>(const UT&amp; value);</td></tr>
				<tr><td align="right">inline BArray </td><td><a href="#operator += (const BArray&) const">operator += </a>(const BArray&amp; other) const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#operator -= (const UT&)">operator -= </a>(const UT&amp; value);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#operator -= (const BArray&)">operator -= </a>(const BArray&amp; other);</td></tr>
				<tr><td align="right">inline BArray&amp; </td><td><a href="#operator << (const UT&)">operator &lt;&lt; </a>(const UT&amp; value);</td></tr>
				<tr><td align="right">inline BArray&amp; </td><td><a href="#operator << (const BArray&)">operator &lt;&lt; </a>(const BArray&amp; other);</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#operator == (const BArray&) const">operator == </a>(const BArray&amp; other) const;</td></tr>
				<tr><td align="right">inline bool </td><td><a href="#operator != (const BArray&) const">operator != </a>(const BArray&amp; other) const;</td></tr>
			</table>
			<div id="desc">
				<h2>详细介绍：</h2>
				<p>BArray是数组容器，以连续内存块来管理元素，是高效且常用的容器。其中的元素要求有默认构造方法，因为容器内存在一个默认值，此设计是为了加强其容错性。</p><p>数组容器是唯一没有迭代器的容器，因为索引值是最高效的迭代器。</p>
				<p> 以下为对一个数据集进行遍历的示例代码： 
					<br/><pre>BArray&lt;double&gt; nums;
for(int i = 0; i &lt; nums.size(); i++)
{
	double&amp; v = nums[i];
}
					</pre>
				</p><p>需要注意，reset(),clear(),relax()的区别，reset()清除所有元素，但不改变存储空间。clear()清除所有元素且释放内存空间。relax()按照当前元素的数量重新分配合适的内存空间，但不改变元素。</p><p>注意：reset(size),resize(size),reserve(size)三个方法的功能区别。reset调整元素数量，当内存不足时按元素的数量申请合适的存储空间。resize也调整元素数量，对内存空间会按指定的大小重新调整，不保留多余的空间。reserve类似resize，不同之处在于reserve不会对新申请的内存空间生成元素。</p>
			</div>
			<h2 id="docs">成员文档：</h2>
			<div id="BArray() :)">
				<h3>inline BArray() : _def();</h3>
				<p>构建一个空的数组。</p>
			</div>
			<div id="BArray(int size) :)">
				<h3>inline BArray(int size) : _def();</h3>
				<p>构建一个数组，初始化指定数目的元素。</p>
			</div>
			<div id="BArray(const T&, int size) :)">
				<h3>inline BArray(const T&amp; v, int size) : _def();</h3>
				<p>构建一个数组，初始化指定数目的元素。参数v表示用于元素构造时的参数，size是元素的个数。</p>
			</div>
			<div id="BArray(const UT*, int size) :)">
				<h3>inline BArray(const UT* values, int size) : _def();</h3>
				<p>构建一个数组，并从指定的数据段进行拷贝，values类型不限，需元素类型适配。size指定要复制的元素数量。</p>
			</div>
			<div id="BArray(const T*, int size) :)">
				<h3>inline BArray(const T* values, int size) : _def();</h3>
				<p>构建一个数组，并从指定的数据段进行拷贝，values类型与本数组元素类型相同。size指定要复制的元素数量。</p>
			</div>
			<div id="BArray(const BArray<UT>& other) :)">
				<h3>inline BArray(const BArray&lt;UT&gt;&amp; other) : _def();</h3>
				<p>构建一个数组，并从指定的数组中拷贝数据元素，指定的other数组的元素类型不限，需要本数组的元素类型做适配。</p>
			</div>
			<div id="BArray(const BArray& other) :)">
				<h3>inline BArray(const BArray&amp; other) : _def();</h3>
				<p>构建一个数组，并从指定的数组中拷贝数据元素，指定的other数组的元素类型本数组的元素类型相同。</p>
			</div>
			<div id="BArray(const BArray<UT>&, int, int size) :)">
				<h3>inline BArray(const BArray&lt;UT&gt;&amp; other, int pos, int size) : _def();</h3>
				<p>构建一个数组，并从指定的数组中拷贝数据元素，指定的other数组的元素类型不限，需要本数组的元素类型做适配。pos和size参数指定要拷贝的区段。</p>
			</div>
			<div id="BArray(const BArray&, int, int size) :)">
				<h3>inline BArray(const BArray&amp; other, int pos, int size) : _def();</h3>
				<p>构建一个数组，并从指定的数组中拷贝数据元素，指定的other数组的元素类型本数组的元素类型相同。pos和size参数指定要拷贝的区段。</p>
			</div>
			<div id="~BArray()">
				<h3>inline ~BArray();</h3>
				<p>析构此数组，删除所有元素。</p>
			</div>
			<div id="size() const">
				<h3>inline int size() const;</h3>
				<p>获得当前元素数量。</p>
			</div>
			<div id="capacity() const">
				<h3>inline int capacity() const;</h3>
				<p>获得当前已经的内存空间能容纳的元素数量。</p>
			</div>
			<div id="empty() const">
				<h3>inline bool empty() const;</h3>
				<p>判断元素数量是否为0。</p>
			</div>
			<div id="reset()">
				<h3>inline bool reset();</h3>
				<p>清空所有元素，但不释放内存空间。此方法用利于重复使用内容空间，提高运行效率。</p>
			</div>
			<div id="clear()">
				<h3>inline bool clear();</h3>
				<p>清空所有元素，以及已有的内容空间。</p>
			</div>
			<div id="relax()">
				<h3>inline bool relax();</h3>
				<p>对现有内容空间进行部分释放，也适应当前元素个数。此方法用于大量未使用空间明显浪费的问题。</p>
			</div>
			<div id="reset(int)">
				<h3>inline bool reset(int size);</h3>
				<p>此方法将元素个数消减到指定的数量，但不释放内存空间。当size数量大于当前元素数量时，分配更多的内存空间，并生成新元素以使用数量达到size。</p>
			</div>
			<div id="resize(int)">
				<h3>inline bool resize(int size);</h3>
				<p>重置元素个数，并且不会保留多余内容空间。此方法使用时会认为本数组不会操作更多的元素。</p>
			</div>
			<div id="reserve(int)">
				<h3>inline bool reserve(int size);</h3>
				<p>保留指定数量的内存空间，但不实例化元素。若当前数组中的元素数据超过指定的数量，那么多出部分的元素会被删除。</p>
			</div>
			<div id="check(int) const">
				<h3>inline bool check(int index) const;</h3>
				<p>检查index是否是有效索引值。</p>
			</div>
			<div id="set(int, const T&)">
				<h3>inline bool set(int pos, const T&amp; value);</h3>
				<p>重置指定位置的元素数据。</p>
			</div>
			<div id="set(int, const T*, int)">
				<h3>inline bool set(int pos, const T* values, int size);</h3>
				<p>重置指定位置的元素数据，pos是本数组中的开始位置，values是给定的外部数据位置，size是要拷贝的元素数量。如果本数组的空间用完了就结束操作。</p>
			</div>
			<div id="set(int, const BArray<T>&)">
				<h3>inline bool set(int pos, const BArray&lt;T&gt;&amp; other);</h3>
				<p>重置指定位置的元素数据，pos是本数组中的开始位置。此方法将拷贝其它数组的所有元素。如果本数组的空间用完了就结束操作。</p>
			</div>
			<div id="fill(const T&)">
				<h3>inline bool fill(const T&amp; value);</h3>
				<p>将此数组中的所有元素重置为指定的值。</p>
			</div>
			<div id="fill(const T*, int)">
				<h3>inline bool fill(const T* data, int size);</h3>
				<p>将此数组中的所有元素按顺序重置为指定的值，data指定外部数据位置，size指示要使用的数据个数。如果本数组元素个数少于size不进行内存扩张。若本数组的元素个数多于指定数据的数量，那么多余的元素不作改变。</p>
			</div>
			<div id="fill(const BArray<T>&)">
				<h3>inline bool fill(const BArray&lt;T&gt;&amp; other);</h3>
				<p>将此数组中的所有元素按顺序重置为指定的值，other指定一个外部数组。如果本数组元素个数少于指定的数组大小不进行内存扩张。若本数组的元素个数多于指定数据的数量，那么多余的元素不作改变。</p>
			</div>
			<div id="fill(int, const T&, int)">
				<h3>inline bool fill(int pos, const T&amp; value, int size);</h3>
			</div>
			<div id="fill(int, const T*, int)">
				<h3>inline bool fill(int pos, const T* data, int size);</h3>
			</div>
			<div id="fill(int, const BArray<T>&)">
				<h3>inline bool fill(int pos, const BArray&lt;T&gt;&amp; other);</h3>
			</div>
			<div id="find(const UT&,int) const">
				<h3>inline int find(const UT&amp; value, int pos = 0) const;</h3>
			</div>
			<div id="find(int, const UT*, int) const">
				<h3>inline int find(int pos, const UT* values, int size) const;</h3>
			</div>
			<div id="find(int, const T*, int) const">
				<h3>inline int find(int pos, const T* values, int size) const;</h3>
			</div>
			<div id="find(int, const BArray<UT>&) const">
				<h3>inline int find(int pos, const BArray&lt;UT&gt;&amp; other) const;</h3>
			</div>
			<div id="find(int, const BArray&) const">
				<h3>inline int find(int pos, const BArray&amp; other) const;</h3>
			</div>
			<div id="rfind(const UT&,int) const">
				<h3>inline int rfind(const UT&amp; value, int pos = -1) const;</h3>
			</div>
			<div id="find_min() const">
				<h3>inline int find_min() const;</h3>
			</div>
			<div id="find_max() const">
				<h3>inline int find_max() const;</h3>
			</div>
			<div id="count(const UT&) const">
				<h3>inline int count(const UT&amp; value) const;</h3>
			</div>
			<div id="contain(const UT&) const">
				<h3>inline bool contain(const UT&amp; value) const;</h3>
			</div>
			<div id="move(int, int)">
				<h3>inline bool move(int index, int dest);</h3>
				<p>将本数组中的index位置的数据移动到dest位置，只是单纯的数据迁移。</p>
			</div>
			<div id="swap(int, int)">
				<h3>inline bool swap(int index0, int index1);</h3>
				<p>对本数组中指定的两个位置的数据进行交换，只是单纯的数据迁移。</p>
			</div>
			<div id="reverse()">
				<h3>inline bool reverse();</h3>
				<p>翻转整个数组，使用每个元素的顺序和之前相反。</p>
			</div>
			<div id="replace(const T&, const T&)">
				<h3>inline int replace(const T&amp; oldValue, const T&amp; newValue);</h3>
				<p>替换所有等于oldValue的元素为新的值newValue，返回替换掉的元素个数。</p>
			</div>
			<div id="sort(const FUNC&,int)">
				<h3>inline bool sort(const FUNC&amp; func, int dir = 1);</h3>
			</div>
			<div id="sort(int)">
				<h3>inline bool sort(int dir = 1);</h3>
				<p>对数组进行排序，dir指定排序的方向，dir大于0表示从小到大，dir小于0表示从大到小。</p>
			</div>
			<div id="raise(const UT&)">
				<h3>inline bool raise(const UT&amp; value);</h3>
				<p>将数组中等于指定值的元素移动到前端。</p>
			</div>
			<div id="lower(const UT&)">
				<h3>inline bool lower(const UT&amp; value);</h3>
				<p>将数组中等于指定值的元素移动到末端。</p>
			</div>
			<div id="first()">
				<h3>inline T&amp; first();</h3>
				<p>获得第一个元素的引用。</p>
			</div>
			<div id="first() const">
				<h3>inline const T&amp; first() const;</h3>
			</div>
			<div id="middle()">
				<h3>inline T&amp; middle();</h3>
				<p>获得数组中间位置的元素的引用。</p>
			</div>
			<div id="middle() const">
				<h3>inline const T&amp; middle() const;</h3>
				<p>获得数组中间位置的元素的常量引用。</p>
			</div>
			<div id="last()">
				<h3>inline T&amp; last();</h3>
				<p>获得最后一个元素的引用。</p>
			</div>
			<div id="last() const">
				<h3>inline const T&amp; last() const;</h3>
			</div>
			<div id="min()">
				<h3>inline T&amp; min();</h3>
				<p>获得所有元素中最小元素的引用。</p>
			</div>
			<div id="min() const">
				<h3>inline const T&amp; min() const;</h3>
			</div>
			<div id="max()">
				<h3>inline T&amp; max();</h3>
				<p>获得所有元素中最大元素的引用。</p>
			</div>
			<div id="max() const">
				<h3>inline const T&amp; max() const;</h3>
			</div>
			<div id="data()">
				<h3>inline T* data();</h3>
				<p>取得此数组中数据的地址，且可对数值直接进行修改，操作时要注意。</p>
			</div>
			<div id="data() const">
				<h3>inline const T* data() const;</h3>
			</div>
			<div id="data(int)">
				<h3>inline T* data(int index);</h3>
				<p>取得此数组中指定元素的地址，且可对数值直接进行修改，操作时要注意。</p>
			</div>
			<div id="data(int) const">
				<h3>inline const T* data(int index) const;</h3>
			</div>
			<div id="at(int)">
				<h3>inline T&amp; at(int index);</h3>
				<p>获得指定位置的元素的引用，可对其进行修改。</p>
			</div>
			<div id="at(int) const">
				<h3>inline const T&amp; at(int index) const;</h3>
			</div>
			<div id="def()">
				<h3>inline T&amp; def();</h3>
				<p>获得默认元素的引用，可对其进行修改。</p>
			</div>
			<div id="def() const">
				<h3>inline const T&amp; def() const;</h3>
			</div>
			<div id="expand(int)">
				<h3>inline bool expand(int size);</h3>
				<p>对此数组的末端添加若干个默认构造的元素，size指定添加元素的数量。成功则返回true。</p>
			</div>
			<div id="append()">
				<h3>inline T&amp; append();</h3>
				<p>对此数组的末端添加一个默认构造的元素，成功则返回新的元素的引用。</p>
			</div>
			<div id="append(const UT&,int)">
				<h3>inline bool append(const UT&amp; value, int size = 1);</h3>
			</div>
			<div id="append(const T&,int)">
				<h3>inline bool append(const T&amp; value, int size = 1);</h3>
				<p>对此数组的末端添加若干个元素，使用value对它们进行构造，sizer指定要添加的个数，默认是一个。</p>
			</div>
			<div id="append(const UT*, int)">
				<h3>inline bool append(const UT* values, int size);</h3>
				<p>对此数组的末端添加若干个元素，使用指定的外部数据进行构造，values指定数据位置，size指示要添加的个数。</p>
			</div>
			<div id="append(const T*, int)">
				<h3>inline bool append(const T* values, int size);</h3>
				<p>对此数组的末端添加若干个元素，使用指定的外部数据进行构造，values指定数据位置，size指示要添加的个数。</p>
			</div>
			<div id="append(const BArray<UT>&,int,int)">
				<h3>inline bool append(const BArray&lt;UT&gt;&amp; other, int pos = 0, int size = -1);</h3>
				<p>对此数组的末端添加若干个元素，使用指定的其它数组的数据进行构造，pos指定数据起始位置，size指示要添加的个数。</p>
			</div>
			<div id="append(const BArray&,int,int)">
				<h3>inline bool append(const BArray&amp; other, int pos = 0, int size = -1);</h3>
				<p>对此数组的末端添加若干个元素，使用指定的其它数组的数据进行构造，pos指定数据起始位置，size指示要添加的个数。</p>
			</div>
			<div id="prepend()">
				<h3>inline T&amp; prepend();</h3>
				<p>对此数组的前端添加一个默认构造的元素，成功则返回新的元素的引用。</p>
			</div>
			<div id="prepend(const UT&,int)">
				<h3>inline bool prepend(const UT&amp; value, int size = 1);</h3>
			</div>
			<div id="prepend(const T&,int)">
				<h3>inline bool prepend(const T&amp; value, int size = 1);</h3>
				<p>对此数组的前端添加若干个元素，使用value对它们进行构造，sizer指定要添加的个数，默认是一个。</p>
			</div>
			<div id="prepend(const UT*, int)">
				<h3>inline bool prepend(const UT* values, int size);</h3>
				<p>对此数组的前端添加若干个元素，使用指定的外部数据进行构造，values指定数据位置，size指示要添加的个数。</p>
			</div>
			<div id="prepend(const T*, int)">
				<h3>inline bool prepend(const T* values, int size);</h3>
				<p>对此数组的前端添加若干个元素，使用指定的外部数据进行构造，values指定数据位置，size指示要添加的个数。</p>
			</div>
			<div id="prepend(const BArray<UT>&,int,int)">
				<h3>inline bool prepend(const BArray&lt;UT&gt;&amp; other, int pos = 0, int size = -1);</h3>
				<p>对此数组的前端添加若干个元素，使用指定的其它数组的数据进行构造，pos指定数据起始位置，size指示要添加的个数。</p>
			</div>
			<div id="prepend(const BArray&,int,int)">
				<h3>inline bool prepend(const BArray&amp; other, int pos = 0, int size = -1);</h3>
				<p>对此数组的末端添加若干个元素，使用指定的其它数组的数据进行构造，pos指定数据起始位置，size指示要添加的个数。</p>
			</div>
			<div id="insert(int)">
				<h3>inline T&amp; insert(int pos);</h3>
				<p>向此数组的指定位置插入一个默认构造的元素，并返回此元素的引用。</p>
			</div>
			<div id="insert(int, const UT&,int)">
				<h3>inline bool insert(int pos, const UT&amp; value, int size = 1);</h3>
				<p>向此数组的指定位置添加若干个元素，使用指定的value进行构造，size指定添加的数量，默认为一个。</p>
			</div>
			<div id="insert(int, const T&,int)">
				<h3>inline bool insert(int pos, const T&amp; value, int size = 1);</h3>
				<p>向此数组的指定位置添加若干个元素，使用指定的value进行构造，size指定添加的数量，默认为一个。</p>
			</div>
			<div id="insert(int, const UT*, int)">
				<h3>inline bool insert(int pos, const UT* values, int size);</h3>
				<p>向此数组的指定位置添加若干个元素，依次使用指定的values进行构造，size指定添加的数量，需要注意values中应该至少有size个数据。</p>
			</div>
			<div id="insert(int, const T*, int)">
				<h3>inline bool insert(int pos, const T* values, int size);</h3>
				<p>向此数组的指定位置添加若干个元素，依次使用指定的values进行构造，size指定添加的数量，需要注意values中应该至少有size个数据。</p>
			</div>
			<div id="insert(int, const BArray<UT>&,int,int)">
				<h3>inline bool insert(int pos, const BArray&lt;UT&gt;&amp; other, int first = 0, int size = -1);</h3>
				<p>向此数组的指定位置添加若干个元素，依次使用指定的其它数组数据进行构造，first指定第一个使用的数据位置，size指定添加的数量，如果other数组中没那么多数据，则以实际个数为准。</p>
			</div>
			<div id="insert(int, const BArray&,int,int)">
				<h3>inline bool insert(int pos, const BArray&amp; other, int first = 0, int size = -1);</h3>
				<p>向此数组的指定位置添加若干个元素，依次使用指定的其它数组数据进行构造，first指定第一个使用的数据位置，size指定添加的数量，如果other数组中没那么多数据，则以实际个数为准。</p>
			</div>
			<div id="remove(int,int)">
				<h3>inline bool remove(int pos, int count = 1);</h3>
				<p>从数组中删除若干个元素，pos指定删除的元素的位置，count指定要删除的元素的个数，默认为1个。</p>
			</div>
			<div id="remove(const UT&)">
				<h3>inline bool remove(const UT&amp; value);</h3>
				<p>从数组中删除一个等于给定的值的元素，只删除一个。</p>
			</div>
			<div id="remove(const T&)">
				<h3>inline bool remove(const T&amp; value);</h3>
				<p>从数组中删除一个等于给定的值的元素，只删除一个。</p>
			</div>
			<div id="remove(const BArray<UT>&)">
				<h3>inline bool remove(const BArray&lt;UT&gt;&amp; other);</h3>
				<p>从数组中删除其它的数组中存在的所有元素，当然每个元素只删除一次。</p>
			</div>
			<div id="remove(const BArray&)">
				<h3>inline bool remove(const BArray&amp; other);</h3>
				<p>从数组中删除其它的数组中存在的所有元素，当然每个元素只删除一次。</p>
			</div>
			<div id="push()">
				<h3>inline T&amp; push();</h3>
				<p>向数组末端添加一个默认构造的元素，功能与append()一至。</p>
			</div>
			<div id="push(const T&)">
				<h3>inline bool push(const T&amp; value);</h3>
				<p>向数组末端添加一个元素，使用value为其赋值，功能与append(value)一至。</p>
			</div>
			<div id="pop()">
				<h3>inline bool pop();</h3>
				<p>删除数组末端的一个元素。</p>
			</div>
			<div id="pop(T&)">
				<h3>inline bool pop(T&amp; value);</h3>
				<p>删除数组末端的一个元素，删除前将其值赋给指定的value。</p>
			</div>
			<div id="operator()(int)">
				<h3>inline T&amp; operator()(int index);</h3>
				<p>获得指定位置的元素的引用，此方法会对index有效性进行判断，若索引值无效则返回默认值。</p>
			</div>
			<div id="operator()(int) const">
				<h3>inline const T&amp; operator()(int index) const;</h3>
			</div>
			<div id="operator[](int)">
				<h3>inline T&amp; operator[](int index);</h3>
				<p>直接获得指定位置的元素的引用，效率会很高。</p>
			</div>
			<div id="operator[](int) const">
				<h3>inline const T&amp; operator[](int index) const;</h3>
			</div>
			<div id="operator = (const BArray<UT>&)">
				<h3>inline const BArray&amp; operator = (const BArray&lt;UT&gt;&amp; other);</h3>
				<p>将此数组的内容完全替换成指定的数组内容，返回自身常量引用。</p>
			</div>
			<div id="operator = (const BArray&)">
				<h3>inline const BArray&amp; operator = (const BArray&amp; other);</h3>
				<p>将此数组的内容完全替换成指定的数组内容，返回自身常量引用。</p>
			</div>
			<div id="operator + (const UT&) const">
				<h3>inline BArray operator + (const UT&amp; value) const;</h3>
			</div>
			<div id="operator + (const BArray&) const">
				<h3>inline BArray operator + (const BArray&amp; other) const;</h3>
			</div>
			<div id="operator += (const UT&)">
				<h3>inline void operator += (const UT&amp; value);</h3>
				<p>向本数组末端添加一个值，功能相当于append(value)。</p>
			</div>
			<div id="operator += (const BArray&) const">
				<h3>inline BArray operator += (const BArray&amp; other) const;</h3>
			</div>
			<div id="operator -= (const UT&)">
				<h3>inline bool operator -= (const UT&amp; value);</h3>
				<p>如果本数组末尾的元素等于指定的值，则将其删除。</p>
			</div>
			<div id="operator -= (const BArray&)">
				<h3>inline bool operator -= (const BArray&amp; other);</h3>
				<p>如果本数组末尾的若干元素分别等于指定的数组的各个值，则将这些元素删除。</p>
			</div>
			<div id="operator << (const UT&)">
				<h3>inline BArray&amp; operator &lt;&lt; (const UT&amp; value);</h3>
				<p>向此数组中追加数值，并返回自身的引用。</p>
			</div>
			<div id="operator << (const BArray&)">
				<h3>inline BArray&amp; operator &lt;&lt; (const BArray&amp; other);</h3>
				<p>向此数组中追加别的数组的数据，并返回自身的引用。</p>
			</div>
			<div id="operator == (const BArray&) const">
				<h3>inline bool operator == (const BArray&amp; other) const;</h3>
				<p>判断是否与另一个数组相同，即元素数量相同且每个同位置的元素也都相同。</p>
			</div>
			<div id="operator != (const BArray&) const">
				<h3>inline bool operator != (const BArray&amp; other) const;</h3>
				<p>判断是否与另一个数组不相同，即元素数量不相同或同位置的元素有不相同的。</p>
			</div>
		</div>
	</body>
</html>